{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuration for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = 'google.colab' in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt-get install -y xvfb python-opengl > /dev/null 2>&1\n",
    "    !pip install gym pyvirtualdisplay > /dev/null 2>&1\n",
    "    !pip install JSAnimation==0.1\n",
    "    !pip install pyglet==1.3.2\n",
    "    \n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02. PPO\n",
    "\n",
    "- PPO: [J. Schulman et al., \"Proximal Policy Optimization Algorithms.\" arXiv preprint arXiv:1707.06347, 2017.](https://arxiv.org/abs/1707.06347.pdf)\n",
    "- TRPO: [Schulman, John, et al. \"Trust region policy optimization.\" International conference on machine learning. 2015.](http://proceedings.mlr.press/v37/schulman15.pdf)\n",
    "\n",
    "There are two kinds of algorithms of PPO: PPO-Penalty and PPO-Clip. Here, we'll implement PPO-clip version.\n",
    "\n",
    "TRPO computes the gradients with a complex second-order method. On the other hand, PPO tries to solve the problem with a first-order methods that keep new polices close to old. To simplify the surrogate objective, let $r(\\theta)$ denote the probability ratio\n",
    "\n",
    "$$ L^{CPI}(\\theta) = \\hat {\\mathbb{E}}_t \\left [ {\\pi_\\theta(a_t|s_t) \\over \\pi_{\\theta_{old}}(a_t|s_t)} \\hat A_t\\right] = \\hat {\\mathbb{E}}_t \\left [ r_t(\\theta) \\hat A_t \\right ].$$\n",
    "\n",
    "The objective is penalized further away from $r_t(\\theta)$\n",
    "\n",
    "$$ L^{CLIP}(\\theta)=\\hat {\\mathbb{E}}_t \\left [ \\min(r_t(\\theta) \\hat A_t, \\text{clip}(r_t(\\theta), 1-\\epsilon, 1+\\epsilon)\\hat A_t) \\right ] $$\n",
    "\n",
    "If the advantage is positive, the objective will increase. As a result, the action becomes more likely. If advantage is negative, the objective will decrease. AS a result, the action becomes less likely."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from collections import deque\n",
    "from typing import Deque, Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "from torch.distributions import Normal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.backends.cudnn.enabled:\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "\n",
    "seed = 777\n",
    "torch.manual_seed(seed)\n",
    "np.random.seed(seed)\n",
    "random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "We will use two separated networks for actor and critic respectively. The actor network consists of two fully connected hidden layer with ReLU branched out two fully connected output layers for mean and standard deviation of Gaussian distribution. Pendulum-v0 has only one action which has a range from -2 to 2. In order to fit the range, the actor outputs the mean value with tanh. The result will be scaled in ActionNormalizer class. On the one hand, the critic network has three fully connected layers as two hidden layers (ReLU) and an output layer. One thing to note is that we initialize the last layers' weights and biases as uniformly distributed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_layer_uniform(layer: nn.Linear, init_w: float = 3e-3) -> nn.Linear:\n",
    "    \"\"\"Init uniform parameters on the single layer.\"\"\"\n",
    "    layer.weight.data.uniform_(-init_w, init_w)\n",
    "    layer.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    return layer\n",
    "\n",
    "class Actor(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int, \n",
    "        log_std_min: int = -20,\n",
    "        log_std_max: int = 0,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Actor, self).__init__()\n",
    "\n",
    "        self.log_std_min = log_std_min\n",
    "        self.log_std_max = log_std_max\n",
    "        self.hidden = nn.Linear(in_dim, 32)\n",
    "\n",
    "        self.mu_layer = nn.Linear(32, out_dim)\n",
    "        self.mu_layer = init_layer_uniform(self.mu_layer)\n",
    "\n",
    "        self.log_std_layer = nn.Linear(32, out_dim)\n",
    "        self.log_std_layer = init_layer_uniform(self.log_std_layer)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden(state))\n",
    "        \n",
    "        mu = torch.tanh(self.mu_layer(x))\n",
    "        log_std = torch.tanh(self.log_std_layer(x))\n",
    "        log_std = self.log_std_min + 0.5 * (\n",
    "            self.log_std_max - self.log_std_min\n",
    "        ) * (log_std + 1)\n",
    "        std = torch.exp(log_std)\n",
    "\n",
    "        dist = Normal(mu, std)\n",
    "        action = dist.sample()\n",
    "\n",
    "        return action, dist\n",
    "\n",
    "\n",
    "class Critic(nn.Module):\n",
    "    def __init__(self, in_dim: int):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Critic, self).__init__()\n",
    "\n",
    "        self.hidden = nn.Linear(in_dim, 64)\n",
    "        self.out = nn.Linear(64, 1)\n",
    "        self.out = init_layer_uniform(self.out)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden(state))\n",
    "        value = self.out(x)\n",
    "\n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GAE\n",
    "\n",
    "*GAE* help to reduce variance while maintaining a proper level of bias. By adjusting parameters $\\lambda \\in [0, 1]$ and $\\gamma \\in [0, 1]$. Please see [the paper](https://arxiv.org/pdf/1506.02438) for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_gae(\n",
    "    next_value: list, \n",
    "    rewards: list, \n",
    "    masks: list, \n",
    "    values: list, \n",
    "    gamma: float, \n",
    "    tau: float\n",
    ") -> List:\n",
    "    \"\"\"Compute gae.\"\"\"\n",
    "    values = values + [next_value]\n",
    "    gae = 0\n",
    "    returns: Deque[float] = deque()\n",
    "\n",
    "    for step in reversed(range(len(rewards))):\n",
    "        delta = (\n",
    "            rewards[step]\n",
    "            + gamma * values[step + 1] * masks[step]\n",
    "            - values[step]\n",
    "        )\n",
    "        gae = delta + gamma * tau * masks[step] * gae\n",
    "        returns.appendleft(gae + values[step])\n",
    "\n",
    "    return list(returns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PPO Agent\n",
    "Here is a summary of PPOAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "|---               |---                                                   |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|_plot             | plot the training progresses.                        |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PPO updates the model several times(`epoch`) using the stacked memory. By `ppo_iter` function, It yield the samples of stacked memory by interacting a environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ppo_iter(\n",
    "    epoch: int,\n",
    "    mini_batch_size: int,\n",
    "    states: torch.Tensor,\n",
    "    actions: torch.Tensor,\n",
    "    values: torch.Tensor,\n",
    "    log_probs: torch.Tensor,\n",
    "    returns: torch.Tensor,\n",
    "    advantages: torch.Tensor,\n",
    "):\n",
    "    \"\"\"Yield mini-batches.\"\"\"\n",
    "    batch_size = states.size(0)\n",
    "    for _ in range(epoch):\n",
    "        for _ in range(batch_size // mini_batch_size):\n",
    "            rand_ids = np.random.choice(batch_size, mini_batch_size)\n",
    "            yield states[rand_ids, :], actions[rand_ids], values[\n",
    "                rand_ids\n",
    "            ], log_probs[rand_ids], returns[rand_ids], advantages[rand_ids]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PPOAgent:\n",
    "    \"\"\"PPO Agent.\n",
    "    Attributes:\n",
    "        env (gym.Env): Gym env for training\n",
    "        gamma (float): discount factor\n",
    "        tau (float): lambda of generalized advantage estimation (GAE)\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): amount of clipping surrogate objective\n",
    "        epoch (int): the number of update\n",
    "        rollout_len (int): the number of rollout\n",
    "        entropy_weight (float): rate of weighting entropy into the loss function\n",
    "        actor (nn.Module): target actor model to select actions\n",
    "        critic (nn.Module): critic model to predict state values\n",
    "        transition (list): temporory storage for the recent transition\n",
    "        device (torch.device): cpu / gpu\n",
    "        total_step (int): total step numbers\n",
    "        is_test (bool): flag to show the current mode (train / test)        \n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        env: gym.Env,\n",
    "        batch_size: int,\n",
    "        gamma: float,\n",
    "        tau: float,\n",
    "        epsilon: float,\n",
    "        epoch: int,\n",
    "        rollout_len: int,\n",
    "        entropy_weight: float,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        self.env = env\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = epsilon\n",
    "        self.epoch = epoch\n",
    "        self.rollout_len = rollout_len\n",
    "        self.entropy_weight = entropy_weight\n",
    "\n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.shape[0]\n",
    "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.critic = Critic(obs_dim).to(self.device)\n",
    "\n",
    "        # optimizer\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=0.001)\n",
    "        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=0.005)\n",
    "\n",
    "        # memory for training\n",
    "        self.states: List[torch.Tensor] = []\n",
    "        self.actions: List[torch.Tensor] = []\n",
    "        self.rewards: List[torch.Tensor] = []\n",
    "        self.values: List[torch.Tensor] = []\n",
    "        self.masks: List[torch.Tensor] = []\n",
    "        self.log_probs: List[torch.Tensor] = []\n",
    "\n",
    "        # total steps count\n",
    "        self.total_step = 1\n",
    "\n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        state = torch.FloatTensor(state).to(self.device)\n",
    "        action, dist = self.actor(state)\n",
    "        selected_action = dist.mean if self.is_test else action\n",
    "\n",
    "        if not self.is_test:\n",
    "            value = self.critic(state)\n",
    "            self.states.append(state)\n",
    "            self.actions.append(selected_action)\n",
    "            self.values.append(value)\n",
    "            self.log_probs.append(dist.log_prob(selected_action))\n",
    "\n",
    "        return selected_action.cpu().detach().numpy()\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "        next_state = np.reshape(next_state, (1, -1)).astype(np.float64)\n",
    "        reward = np.reshape(reward, (1, -1)).astype(np.float64)\n",
    "        done = np.reshape(done, (1, -1))\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.rewards.append(torch.FloatTensor(reward).to(self.device))\n",
    "            self.masks.append(torch.FloatTensor(1 - done).to(self.device))\n",
    "\n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(\n",
    "        self, next_state: np.ndarray\n",
    "    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "\n",
    "        next_state = torch.FloatTensor(next_state).to(device)\n",
    "        next_value = self.critic(next_state)\n",
    "\n",
    "        returns = compute_gae(\n",
    "            next_value,\n",
    "            self.rewards,\n",
    "            self.masks,\n",
    "            self.values,\n",
    "            self.gamma,\n",
    "            self.tau,\n",
    "        )\n",
    "\n",
    "        states = torch.cat(self.states).view(-1, 3)\n",
    "        actions = torch.cat(self.actions)\n",
    "        returns = torch.cat(returns).detach()\n",
    "        values = torch.cat(self.values).detach()\n",
    "        log_probs = torch.cat(self.log_probs).detach()\n",
    "        advantages = returns - values\n",
    "\n",
    "        actor_losses, critic_losses = [], []\n",
    "\n",
    "        for state, action, old_value, old_log_prob, return_, adv in ppo_iter(\n",
    "            epoch=self.epoch,\n",
    "            mini_batch_size=self.batch_size,\n",
    "            states=states,\n",
    "            actions=actions,\n",
    "            values=values,\n",
    "            log_probs=log_probs,\n",
    "            returns=returns,\n",
    "            advantages=advantages,\n",
    "        ):\n",
    "            # calculate ratios\n",
    "            _, dist = self.actor(state)\n",
    "            log_prob = dist.log_prob(action)\n",
    "            ratio = (log_prob - old_log_prob).exp()\n",
    "\n",
    "            # actor_loss\n",
    "            surr_loss = ratio * adv\n",
    "            clipped_surr_loss = (\n",
    "                torch.clamp(ratio, 1.0 - self.epsilon, 1.0 + self.epsilon) * adv\n",
    "            )\n",
    "\n",
    "            # entropy\n",
    "            entropy = dist.entropy().mean()\n",
    "\n",
    "            actor_loss = (\n",
    "                -torch.min(surr_loss, clipped_surr_loss).mean()\n",
    "                - entropy * self.entropy_weight\n",
    "            )\n",
    "\n",
    "            # critic_loss\n",
    "            value = self.critic(state)\n",
    "            #clipped_value = old_value + (value - old_value).clamp(-0.5, 0.5)\n",
    "            critic_loss = (return_ - value).pow(2).mean()\n",
    "        \n",
    "            # train critic\n",
    "            self.critic_optimizer.zero_grad()\n",
    "            critic_loss.backward(retain_graph=True)\n",
    "            self.critic_optimizer.step()\n",
    "\n",
    "            # train actor\n",
    "            self.actor_optimizer.zero_grad()\n",
    "            actor_loss.backward()\n",
    "            self.actor_optimizer.step()\n",
    "\n",
    "            actor_losses.append(actor_loss.item())\n",
    "            critic_losses.append(critic_loss.item())\n",
    "\n",
    "        self.states, self.actions, self.rewards = [], [], []\n",
    "        self.values, self.masks, self.log_probs = [], [], []\n",
    "\n",
    "        actor_loss = sum(actor_losses) / len(actor_losses)\n",
    "        critic_loss = sum(critic_losses) / len(critic_losses)\n",
    "\n",
    "        return actor_loss, critic_loss\n",
    "\n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "\n",
    "        state = self.env.reset()\n",
    "        state = np.expand_dims(state, axis=0)\n",
    "\n",
    "        actor_losses, critic_losses = [], []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        while self.total_step <= num_frames + 1:\n",
    "            for _ in range(self.rollout_len):\n",
    "                self.total_step += 1\n",
    "                action = self.select_action(state)\n",
    "                next_state, reward, done = self.step(action)\n",
    "\n",
    "                state = next_state\n",
    "                score += reward[0][0]\n",
    "\n",
    "                # if episode ends\n",
    "                if done[0][0]:\n",
    "                    state = env.reset()\n",
    "                    state = np.expand_dims(state, axis=0)\n",
    "                    scores.append(score)\n",
    "                    score = 0\n",
    "\n",
    "                    self._plot(\n",
    "                        self.total_step, scores, actor_losses, critic_losses\n",
    "                    )\n",
    "\n",
    "            actor_loss, critic_loss = self.update_model(next_state)\n",
    "            actor_losses.append(actor_loss)\n",
    "            critic_losses.append(critic_loss)\n",
    "\n",
    "        # termination\n",
    "        self.env.close()\n",
    "\n",
    "    def test(self):\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "\n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "\n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "\n",
    "        return frames\n",
    "\n",
    "    def _plot(\n",
    "        self,\n",
    "        frame_idx: int,\n",
    "        scores: List[float],\n",
    "        actor_losses: List[float],\n",
    "        critic_losses: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "\n",
    "        def subplot(loc: int, title: str, values: List[float]):\n",
    "            plt.subplot(loc)\n",
    "            plt.title(title)\n",
    "            plt.plot(values)\n",
    "\n",
    "        subplot_params = [\n",
    "            (131, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
    "            (132, \"actor_loss\", actor_losses),\n",
    "            (133, \"critic_loss\", critic_losses),\n",
    "        ]\n",
    "\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(30, 5))\n",
    "        for loc, title, values in subplot_params:\n",
    "            subplot(loc, title, values)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "*ActionNormalizer* is an action wrapper class to normalize the action values ranged in (-1. 1). Thanks to this class, we can make the agent simply select action values within the zero centered range (-1, 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActionNormalizer(gym.ActionWrapper):\n",
    "    \"\"\"Rescale and relocate the actions.\"\"\"\n",
    "\n",
    "    def action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (-1, 1) to (low, high).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = action * scale_factor + reloc_factor\n",
    "        action = np.clip(action, low, high)\n",
    "\n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (low, high) to (-1, 1).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = (action - reloc_factor) / scale_factor\n",
    "        action = np.clip(action, -1.0, 1.0)\n",
    "\n",
    "        return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see [the code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/pendulum.py) and [configurations](https://github.com/openai/gym/blob/cedecb35e3428985fd4efad738befeb75b9077f1/gym/envs/__init__.py#L81) of Pendulum-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# environment\n",
    "env_id = \"Pendulum-v0\"\n",
    "env = gym.make(env_id)\n",
    "env = ActionNormalizer(env)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 100000\n",
    "\n",
    "agent = PPOAgent(\n",
    "    env,\n",
    "    gamma = 0.9,\n",
    "    tau = 0.8,\n",
    "    batch_size = 64,\n",
    "    epsilon = 0.2,\n",
    "    epoch = 64,\n",
    "    rollout_len = 2048,\n",
    "    entropy_weight = 0.005\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  [[-479.04809434]]\n"
     ]
    }
   ],
   "source": [
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgXQJPYZUCCLQNVSTI\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderXQJPYZUCCLQNVSTI\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animXQJPYZUCCLQNVSTI.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animXQJPYZUCCLQNVSTI.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animXQJPYZUCCLQNVSTI.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXQJPYZUCCLQNVSTI.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXQJPYZUCCLQNVSTI.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXQJPYZUCCLQNVSTI.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXQJPYZUCCLQNVSTI.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXQJPYZUCCLQNVSTI.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXQJPYZUCCLQNVSTI.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animXQJPYZUCCLQNVSTI.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectXQJPYZUCCLQNVSTI\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgXQJPYZUCCLQNVSTI\";\n",
       "    var slider_id = \"_anim_sliderXQJPYZUCCLQNVSTI\";\n",
       "    var loop_select_id = \"_anim_loop_selectXQJPYZUCCLQNVSTI\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "  frames[157] = \"\"\n",
       "  frames[158] = \"\"\n",
       "  frames[159] = \"\"\n",
       "  frames[160] = \"\"\n",
       "  frames[161] = \"\"\n",
       "  frames[162] = \"\"\n",
       "  frames[163] = \"\"\n",
       "  frames[164] = \"\"\n",
       "  frames[165] = \"\"\n",
       "  frames[166] = \"\"\n",
       "  frames[167] = \"\"\n",
       "  frames[168] = \"\"\n",
       "  frames[169] = \"\"\n",
       "  frames[170] = \"\"\n",
       "  frames[171] = \"\"\n",
       "  frames[172] = \"\"\n",
       "  frames[173] = \"\"\n",
       "  frames[174] = \"\"\n",
       "  frames[175] = \"\"\n",
       "  frames[176] = \"\"\n",
       "  frames[177] = \"\"\n",
       "  frames[178] = \"\"\n",
       "  frames[179] = \"\"\n",
       "  frames[180] = \"\"\n",
       "  frames[181] = \"\"\n",
       "  frames[182] = \"\"\n",
       "  frames[183] = \"\"\n",
       "  frames[184] = \"\"\n",
       "  frames[185] = \"\"\n",
       "  frames[186] = \"\"\n",
       "  frames[187] = \"\"\n",
       "  frames[188] = \"\"\n",
       "  frames[189] = \"\"\n",
       "  frames[190] = \"\"\n",
       "  frames[191] = \"\"\n",
       "  frames[192] = \"\"\n",
       "  frames[193] = \"\"\n",
       "  frames[194] = \"\"\n",
       "  frames[195] = \"\"\n",
       "  frames[196] = \"\"\n",
       "  frames[197] = \"\"\n",
       "  frames[198] = \"\"\n",
       "  frames[199] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animXQJPYZUCCLQNVSTI = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Imports specifically so we can render outputs in Colab.\n",
    "from matplotlib import animation\n",
    "from JSAnimation.IPython_display import display_animation\n",
    "from IPython.display import display\n",
    "\n",
    "\n",
    "def display_frames_as_gif(frames):\n",
    "    \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "    patch = plt.imshow(frames[0])\n",
    "    plt.axis('off')\n",
    "\n",
    "    def animate(i):\n",
    "        patch.set_data(frames[i])\n",
    "\n",
    "    anim = animation.FuncAnimation(\n",
    "        plt.gcf(), animate, frames = len(frames), interval=50\n",
    "    )\n",
    "    display(display_animation(anim, default_mode='loop'))\n",
    "    \n",
    "        \n",
    "# display \n",
    "display_frames_as_gif(frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
